package com.gydz.gydzbaseframeworkboot.SgsE.controller;

import org.apache.commons.lang.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.web.multipart.MultipartFile;

import java.io.InputStream;
import java.lang.reflect.Field;
import java.text.SimpleDateFormat;
import java.util.*;

// Excel导入工具类
public class ExcelImportUtil {

    /**
     * 读取Excel文件内容
     * @param file 上传文件
     * @param clazz 目标对象类型
     * @param headerRow 标题行号（从0开始）
     * @param <T> 泛型类型
     * @return 解析结果集合
     * @throws
     */
    public static <T> List<T> readExcel(MultipartFile file, Class<T> clazz, int headerRow) throws Exception {
        // 校验文件
        if (file.isEmpty()) {
            throw new IllegalArgumentException("请选择上传文件");
        }

        String fileName = file.getOriginalFilename();
        if (!fileName.matches("^.+\\.(?i)(xls|xlsx)$")) {
            throw new IllegalArgumentException("请上传excel文件");
        }

        Workbook workbook = null;
        try (InputStream is = file.getInputStream()) {
            if (fileName.endsWith("xlsx")) {
                workbook = new XSSFWorkbook(is);
            } else {
                workbook = new HSSFWorkbook(is);
            }

            Sheet sheet = (Sheet) workbook.getSheetAt(0);
            return parseSheet(sheet, clazz, headerRow);
        } finally {
            if (workbook != null) {
                workbook.close();
            }
        }
    }

    private static <T> List<T> parseSheet(Sheet sheet, Class<T> clazz, int headerRow) throws Exception {
        List<T> result = new ArrayList<>();
        Map<Integer, String> columnMapping = new HashMap<>();
        
        // 获取标题行建立列映射
        Row header = sheet.getRow(headerRow);
        for (Cell cell : header) {
            String title = cell.getStringCellValue().trim();
            columnMapping.put(cell.getColumnIndex(), title);
        }

        // 遍历数据行
        for (int i = headerRow + 1; i <= sheet.getLastRowNum(); i++) {
            Row row = sheet.getRow(i);
            if (row == null) continue;

            T obj = clazz.newInstance();
            for (Cell cell : row) {
                String fieldName = convertColumnName(columnMapping.get(cell.getColumnIndex()));
                System.out.println("单元格值："+getCellValue(cell));
                setFieldValue(obj, fieldName, getCellValue(cell));
            }
            result.add(obj);
        }
        return result;
    }

    // 转换列名为字段名（示例：触发时间 -> dtSTime）
    private static String convertColumnName(String columnName) {
        // 根据实际业务需求实现列名到字段名的转换逻辑
        // 添加空指针防护
        if (columnName == null) {
            throw new IllegalArgumentException("列名不能为null");
            // 或者返回默认值：return "unknownField";
        }
        // 此处示例简单处理，建议使用注解方式或映射配置
        switch(columnName) {
            case "触发时间": return "dtsTime";
            case "接口类型": return "uintInterfaceID";
            case "主叫号码": return "vcCallingNumber";
            case "被叫号码": return "vcCalledNumber";
            case "ISUP释放原因": return "intCause";
            // 补充其他字段映射...
            default: return StringUtils.uncapitalize(columnName);
        }
    }

    // 获取单元格值
    private static String getCellValue(Cell cell) {
        if (cell == null) return "";
        DataFormatter formatter = new DataFormatter();
        // 先通过单元格类型做初步筛选
        switch (cell.getCellType()) {
            case Cell.CELL_TYPE_NUMERIC:
                // 仅对数值型单元格做日期判断
                if (DateUtil.isCellDateFormatted(cell)) {
                    System.out.println("数值"+cell.getDateCellValue());
                    Date date = cell.getDateCellValue();
                    System.out.println("日期"+date);
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    return sdf.format(date);
                }
                // 普通数值直接返回格式化结果
                return formatter.formatCellValue(cell);

            case Cell.CELL_TYPE_STRING:
                return cell.getStringCellValue().trim();

            case Cell.CELL_TYPE_FORMULA:
                // 处理公式计算结果
                return handleFormulaCell(cell);

            default:
                return formatter.formatCellValue(cell);
        }
    }

    // 处理公式单元格（辅助方法）
    private static String handleFormulaCell(Cell cell) {
        try {
            return new DataFormatter().formatCellValue(cell);
        } catch (IllegalStateException e) {
            // 公式结果为字符串时的特殊处理
            return cell.getRichStringCellValue().toString();
        }
    }

    // 通过反射设置字段值
    private static <T> void setFieldValue(T obj, String fieldName, String value) throws Exception {
        Field field = obj.getClass().getDeclaredField(fieldName);
        field.setAccessible(true);
        
        // 根据字段类型转换值
        Class<?> type = field.getType();
        if (type == String.class) {
            field.set(obj, value);
        } else if (type == Integer.class || type == int.class) {
            field.set(obj, Integer.parseInt(value));
        } 
        // 可扩展其他类型转换
    }
}
